import { defineStore } from "pinia";
import { ref, computed, onMounted, watch } from "vue";
import { CartItem } from "./types";
import { getProductsDetails } from "@/api/product";
import { showToast } from "vant";

export const useCartStore = defineStore(
	"cart",
	() => {
		// 购物车商品列表
		const cartItems = ref<CartItem[]>([]);
		// 最后更新时间
		const lastPriceUpdateTime = ref<number>(0);
		// 价格是否正在更新
		const isUpdatingPrices = ref(false);
		// 价格更新状态
		const priceUpdateStatus = ref<
			"up-to-date" | "updating" | "changed" | "error"
		>("up-to-date");

		// 初始化加载本地存储的购物车数据
		const initCart = () => {
			const localCart = localStorage.getItem("cart");
			if (localCart) {
				try {
					cartItems.value = JSON.parse(localCart);
					const updateTimeStr = localStorage.getItem("cartUpdateTime");
					if (updateTimeStr) {
						lastPriceUpdateTime.value = parseInt(updateTimeStr);
					}
				} catch (e) {
					console.error("解析购物车数据失败", e);
					cartItems.value = [];
				}
			}
		};

		// 保存购物车到本地存储
		const saveCart = () => {
			localStorage.setItem("cart", JSON.stringify(cartItems.value));
			localStorage.setItem("cartUpdateTime", String(lastPriceUpdateTime.value));
		};

		// 添加商品到购物车
		const addToCart = (product: CartItem, quantity: number = 1) => {
			// 生成商品ID，如果有SKU，使用 product.id_skuId 作为唯一标识
			const uniqueId = product.skuId
				? `${product.id}_${product.skuId}`
				: product.id;

			// 查找是否已存在相同商品
			const existItem = cartItems.value.find((item) => {
				if (product.skuId) {
					return item.skuId === product.skuId && item.id === product.id;
				} else {
					return item.id === product.id && !item.skuId;
				}
			});

			if (existItem) {
				// 如果已存在，增加数量
				const newQuantity = existItem.quantity + quantity;
				// 库存检查
				if (product.availableStock !== undefined) {
					// 如果有可用库存数据，使用可用库存
					if (newQuantity > product.availableStock) {
						showToast(`库存不足，已添加最大可用数量`);
						existItem.quantity = product.availableStock;
					} else {
						existItem.quantity = newQuantity;
					}
				} else if (product.stock !== undefined) {
					// 如果没有可用库存数据，使用总库存
					if (newQuantity > product.stock) {
						showToast(`库存不足，已添加最大可用数量`);
						existItem.quantity = product.stock;
					} else {
						existItem.quantity = newQuantity;
					}
				} else {
					existItem.quantity = newQuantity;
				}
			} else {
				// 如果不存在，添加新商品
				const newItem: CartItem = {
					id: product.id,
					name: product.name,
					price: product.price,
					image: product.image,
					quantity: Math.min(
						quantity,
						product.availableStock || product.stock || quantity
					),
					checked: true,
					stock: product.stock,
					availableStock: product.availableStock,
				};

				// 如果有SKU相关信息，也添加到购物车项中
				if (product.skuId) {
					newItem.skuId = product.skuId;
					newItem.skuSpecs = product.skuSpecs;
				}

				cartItems.value.push(newItem);
			}

			// 保存到本地存储
			saveCart();
		};

		// 从购物车移除商品
		const removeFromCart = (itemId: string | number) => {
			cartItems.value = cartItems.value.filter((item) => {
				// 判断是否是SKU商品
				if (typeof itemId === "string" && itemId.includes("_")) {
					const [productId, skuId] = itemId.split("_");
					return !(
						item.id === parseInt(productId) && item.skuId === parseInt(skuId)
					);
				} else {
					return item.id !== itemId;
				}
			});

			// 保存到本地存储
			saveCart();
		};

		// 更新商品数量
		const updateQuantity = (itemId: string | number, quantity: number) => {
			const item = getCartItem(itemId);
			if (item) {
				const maxQuantity = item.availableStock || item.stock || 99;
				item.quantity = Math.min(Math.max(1, quantity), maxQuantity);

				// 保存到本地存储
				saveCart();
			}
		};

		// 更新商品选中状态
		const updateChecked = (itemId: string | number, checked: boolean) => {
			const item = getCartItem(itemId);
			if (item) {
				item.checked = checked;

				// 保存到本地存储
				saveCart();
			}
		};

		// 获取购物车项
		const getCartItem = (itemId: string | number): CartItem | undefined => {
			// 判断是否是SKU商品
			if (typeof itemId === "string" && itemId.includes("_")) {
				const [productId, skuId] = itemId.split("_");
				return cartItems.value.find(
					(item) =>
						item.id === parseInt(productId) && item.skuId === parseInt(skuId)
				);
			} else {
				// 非SKU商品
				return cartItems.value.find(
					(item) => item.id === itemId && !item.skuId
				);
			}
		};

		// 全选/取消全选
		const toggleCheckAll = (checked: boolean) => {
			cartItems.value.forEach((item) => {
				item.checked = checked;
			});

			// 保存到本地存储
			saveCart();
		};

		// 刷新购物车中商品的价格和库存信息
		const refreshCartPrices = async () => {
			// 避免重复刷新
			if (isUpdatingPrices.value) return;

			// 如果购物车为空，不需要刷新
			if (cartItems.value.length === 0) return;

			// 如果上次更新时间距现在不足5分钟，不更新
			const now = Date.now();
			if (now - lastPriceUpdateTime.value < 5 * 60 * 1000) return;

			try {
				isUpdatingPrices.value = true;

				// 收集所有商品ID
				const productIds = Array.from(
					new Set(cartItems.value.map((item) => item.id))
				);

				// 请求最新的商品信息
				const response = await getProductsDetails(productIds);

				if (response && response.code === 200 && response.data) {
					const products = response.data;

					// 更新购物车中每个商品的价格和库存信息
					let isUpdated = false;

					cartItems.value.forEach((item) => {
						const product = products.find(
							(product: any) => product.id === item.id
						);
						if (product) {
							// 如果是SKU商品
							if (item.skuId && product.skus && product.skus.length > 0) {
								const sku = product.skus.find(
									(sku: any) => sku.id === item.skuId
								);
								if (sku) {
									// 检查价格是否变化
									if (item.price !== sku.price) {
										console.log(
											`商品 ${item.name} (SKU: ${item.skuId}) 价格从 ${item.price} 变为 ${sku.price}`
										);
										item.price = sku.price;
										isUpdated = true;
									}

									// 更新库存信息
									item.stock = sku.stock;
									item.availableStock = sku.availableStock;

									// 如果当前数量超过可用库存，调整数量
									if (item.quantity > sku.availableStock) {
										console.log(
											`商品 ${item.name} (SKU: ${item.skuId}) 数量从 ${item.quantity} 调整为 ${sku.availableStock}`
										);
										item.quantity = Math.max(1, sku.availableStock);
										isUpdated = true;
									}
								}
							} else {
								// 普通商品
								// 检查价格是否变化
								if (item.price !== product.price) {
									console.log(
										`商品 ${item.name} 价格从 ${item.price} 变为 ${product.price}`
									);
									item.price = product.price;
									isUpdated = true;
								}

								// 更新库存信息
								item.stock = product.stock;
								item.availableStock = product.availableStock || product.stock;

								// 如果当前数量超过可用库存，调整数量
								const availableStock = product.availableStock || product.stock;
								if (item.quantity > availableStock) {
									console.log(
										`商品 ${item.name} 数量从 ${item.quantity} 调整为 ${availableStock}`
									);
									item.quantity = Math.max(1, availableStock);
									isUpdated = true;
								}
							}
						}
					});

					// 如果有更新，保存到本地存储
					if (isUpdated) {
						saveCart();
					}

					// 更新最后更新时间
					lastPriceUpdateTime.value = now;
				}
			} catch (error) {
				console.error("刷新购物车价格失败", error);
			} finally {
				isUpdatingPrices.value = false;
			}
		};

		// 计算总数量
		const totalCount = computed(() => {
			return cartItems.value.reduce((total, item) => total + item.quantity, 0);
		});

		// 计算选中的商品
		const checkedItems = computed(() => {
			return cartItems.value.filter((item) => item.checked);
		});

		// 计算选中商品的总价
		const checkedTotal = computed(() => {
			return checkedItems.value.reduce(
				(total, item) => total + item.price * item.quantity,
				0
			);
		});

		// 计算选中商品的总数量
		const checkedCount = computed(() => {
			return checkedItems.value.reduce(
				(total, item) => total + item.quantity,
				0
			);
		});

		// 是否全选
		const isAllChecked = computed(() => {
			return (
				cartItems.value.length > 0 &&
				cartItems.value.every((item) => item.checked)
			);
		});

		// 清空购物车
		const clearCart = () => {
			cartItems.value = [];
			saveCart();
		};

		// 切换商品选中状态
		const toggleChecked = (itemId: string | number, checked?: boolean) => {
			const item = getCartItem(itemId);
			if (item) {
				if (checked !== undefined) {
					item.checked = checked;
				} else {
					item.checked = !item.checked;
				}

				// 保存到本地存储
				saveCart();
			}
		};

		// 价格更新状态
		const priceUpdateInfo = computed(() => {
			return {
				status: priceUpdateStatus.value,
				isUpdating: isUpdatingPrices.value,
				lastUpdateTime: lastPriceUpdateTime.value,
			};
		});

		// 初始化购物车
		initCart();

		// 组件挂载后自动刷新商品价格
		onMounted(() => {
			refreshCartPrices();
		});

		return {
			cartItems,
			totalCount,
			checkedItems,
			checkedTotal,
			checkedCount,
			isAllChecked,
			lastPriceUpdateTime,
			isUpdatingPrices,
			initCart,
			addToCart,
			removeFromCart,
			updateQuantity,
			updateChecked,
			toggleCheckAll,
			refreshCartPrices,
			getCartItem,
			clearCart,
			toggleChecked,
			priceUpdateInfo,
		};
	},
	{
		persist: true,
	}
);
